feat: implement endpoint to support fetching workspace pod log - #1267

diff --git a/workspaces/backend/internal/repositories/logs/repo.go b/workspaces/backend/internal/repositories/logs/repo.go
index f8a7917b..b37afd20 100644
--- a/workspaces/backend/internal/repositories/logs/repo.go
+++ b/workspaces/backend/internal/repositories/logs/repo.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"strings"
 
 	kubefloworgv1beta1 "github.com/kubeflow/notebooks/workspaces/controller/api/v1beta1"
 	corev1 "k8s.io/api/core/v1"
@@ -87,12 +86,6 @@ func (r *LogsRepository) OpenLogStream(ctx context.Context, namespace, workspace
 
 	stream, err := req.Stream(ctx)
 	if err != nil {
-		// When previous=true but the container has never restarted, the Kubernetes
-		// API returns a 400 with a "previous terminated container ... not found"
-		// message. Surface this as a semantic error instead of a generic 500.
-		if opts.Previous && apierrors.IsBadRequest(err) && strings.Contains(err.Error(), "previous terminated container") {
-			return nil, ErrPreviousLogsNotFound
-		}
 		return nil, fmt.Errorf("failed to open log stream for pod %s, container %s: %w", podName, containerName, err)
 	}
 	return stream, nil
@@ -145,47 +138,52 @@ func (r *LogsRepository) resolvePodAndContainer(ctx context.Context, namespace,
 		containerName = podStatus.Containers[0].Name
 	}
 
-	// When requesting current (not previous) logs, ensure the target container has
-	// actually started by inspecting the live Pod status. A container still in the
-	// Waiting state (e.g. PodInitializing, ContainerCreating, ImagePullBackOff) has
-	// no current log stream yet, and the Kubernetes API would return an opaque error;
-	// surface it as a semantic 409 instead. Previous logs are exempt, since a
-	// terminated instance can have logs even while the current instance is Waiting.
-	if !opts.Previous {
-		if err := r.ensureContainerStarted(ctx, namespace, podName, containerName); err != nil {
-			return "", "", err
+	// Inspect the live Pod status to determine whether the requested log stream can
+	// actually exist. Deciding this up front from the typed status lets us return a
+	// semantic error instead of interpreting the opaque error the Kubernetes API
+	// would otherwise return.
+	cs, err := r.findContainerStatus(ctx, namespace, podName, containerName)
+	if err != nil {
+		return "", "", err
+	}
+	if opts.Previous {
+		// A previous instance exists only if the container has terminated at least
+		// once. This holds even while the current instance is Waiting (e.g. a
+		// container in CrashLoopBackOff still has logs from its last run).
+		if cs.LastTerminationState.Terminated == nil {
+			return "", "", ErrPreviousLogsNotFound
 		}
+	} else if cs.State.Waiting != nil {
+		// A container still in the Waiting state (e.g. PodInitializing,
+		// ContainerCreating, ImagePullBackOff) has never started, so it has no log
+		// stream for the current instance yet.
+		return "", "", ErrContainerNotRunning
 	}
 
 	return podName, containerName, nil
 }
 
-// ensureContainerStarted checks the live Pod status and returns ErrContainerNotRunning
-// if the target container is still in the Waiting state (i.e. it has not started yet
-// and therefore has no logs available for the current instance).
-func (r *LogsRepository) ensureContainerStarted(ctx context.Context, namespace, podName, containerName string) error {
+// findContainerStatus returns the live status of the named container, searching both
+// the regular and init container statuses of the pod.
+func (r *LogsRepository) findContainerStatus(ctx context.Context, namespace, podName, containerName string) (*corev1.ContainerStatus, error) {
 	pod, err := r.clientset.CoreV1().Pods(namespace).Get(ctx, podName, metav1.GetOptions{})
 	if err != nil {
 		if apierrors.IsNotFound(err) {
 			// The Workspace status references a pod that no longer exists.
-			return ErrPodNotRunning
+			return nil, ErrPodNotRunning
 		}
-		return fmt.Errorf("failed to get pod %s: %w", podName, err)
+		return nil, fmt.Errorf("failed to get pod %s: %w", podName, err)
 	}
 
-	// Search both regular and init container statuses for the target container.
 	for _, group := range [][]corev1.ContainerStatus{pod.Status.ContainerStatuses, pod.Status.InitContainerStatuses} {
-		for _, cs := range group {
-			if cs.Name != containerName {
-				continue
-			}
-			// A container that is still Waiting has never started and has no logs yet.
-			if cs.State.Waiting != nil {
-				return ErrContainerNotRunning
+		for i := range group {
+			if group[i].Name == containerName {
+				return &group[i], nil
 			}
-			return nil
 		}
 	}
 
-	return ErrContainerNotRunning
+	// The container is declared in the pod spec but has no status yet, so it has not
+	// started and has no logs.
+	return nil, ErrContainerNotRunning
 }